Parallel processing method of an eigenvalue problem for a shared-memory type scalar parallel computer

ABSTRACT

A method for solving an eigenvalue problem is divided into three steps of tri-diagonalizing a matrix; calculating an eigenvalue and an eigenvector based on the tri-diagonal matrix; and converting the eigenvector calculated based on the tri-diagonal matrix and calculating the eigenvector of the original matrix. In particular, since the cost of performing the tri-diagonalization step and original matrix eigenvector calculation step are large, these steps can be processed in parallel and the eigenvalue problem can be solved at high speed.

BACKGROUND OF THE INVENTION

[0001] 1. Field of the Invention

[0002] The present invention relates to matrix calculation in a shared-memory type scalar parallel computer.

[0003] 2. Description of the Related Art

[0004] First, in order to solve the eigenvalue problem of a real symmetric matrix (matrix composed of real numbers, which does not changed even if the matrix elements are transposed) and an Hermitian matrix (matrix composed of complex numbers, which does not changed even if conjugated and transposed) (calculating λ, in which det|A−λI|=0, and the eigenvector thereof if a matrix, a constant and a unit matrix are assumed to be A, λ and I, respectively), tri-diagonalization (conversion into a matrix with a diagonal factor and adjacent factors on both sides only) has been applied. Then, the eigenvalue problem of this tri-diagonal matrix is solved using a multi-section method. The eigenvalue is calculated and the eigenvector is calculated using an inverse repetition method. Then, Householder conversion is applied to the eigenvector, and the eigenvector of the original eigenvalue problem is calculated.

[0005] In a vector parallel computer, an eigenvalue problem is calculated assuming that memory access is fast. However, in the case of a shared-memory type scalar parallel computer, the larger the matrix to be calculated, the greater the number of accesses to shared memory. Therefore, the performance of the computer is greatly decreased by accessing shared memory at low speed, which is a problem. Therefore, a matrix must be calculated effectively using a cache memory with fast access installed in each processor of a shared-memory type scalar parallel computer. Specifically, if a matrix is calculated for each row or column, the number of accesses to shared memory increases. Therefore, a matrix must be divided into blocks and shared memory must be accessed after each processor processes data stored in a cache memory as much as possible. In this way, the number of accesses to shared memory can be reduced. In this case, it becomes necessary for each processor to have a localized algorithm.

[0006] In other words, since a shared-memory type parallel computer does not have fast memory access capability like a vector parallel computer, an algorithm must be designed to increase processing amount against accesses to shared memory.

SUMMARY OF THE INVENTION

[0007] It is an object of the present invention to provide a parallel processing method for calculating an eigenvalue problem at high speed in a shared-memory type scalar parallel computer.

[0008] The parallel processing method of the present invention is a program enabling a computer to solve an eigenvalue problem on a shared-memory type scalar parallel computer. The method comprises dividing a real symmetric matrix or Hermitian matrix blocks, copying each divided block in the work area of memory and tri-diagonalizing the matrix using each product between the divided blocks; calculating an eigenvalue and an eigenvector based on the tri-diagonalized matrix; and converting the eigenvector by Householder conversion in order to transform the calculation into the parallel calculation of matrix calculations with a prescribed block width and calculating the eigenvector of the original matrix.

[0009] According to the present invention, an eigenvalue problem can be solved with the calculation localized as much as possible in each processor of a shared-memory type scalar parallel computer. Therefore, delay due to frequent accesses to shared memory can be minimized, and the effect of parallel calculation can be maximized.

BRIEF DESCRIPTION OF THE DRAWINGS

[0010] The present invention will be more apparent from the following detailed description in conjunction with the accompanying drawings, in which:

[0011]FIG. 1 shows the hardware configuration of a shared-memory type scalar parallel computer assumed in the preferred embodiment of the present invention;

[0012]FIG. 2 shows the algorithm of the preferred embodiment of the present invention (No. 1);

[0013]FIG. 3 shows the algorithm of the preferred embodiment of the present invention (No. 2);

[0014]FIGS. 4A through 4F show the algorithm of the preferred embodiment of the present invention (No. 3);

[0015]FIGS. 5A through 5F show the algorithm of the preferred embodiment of the present invention (No. 4);

[0016]FIG. 6 shows the algorithm of the preferred embodiment of the present invention (No. 5);

[0017]FIG. 7 shows the algorithm of the preferred embodiment of the present invention (No. 6);

[0018]FIG. 8 shows the algorithm of the preferred embodiment of the present invention (No. 7);

[0019]FIG. 9 shows the algorithm of the preferred embodiment of the present invention (No. 8);

[0020]FIG. 10 shows the algorithm of the preferred embodiment of the present invention (No. 9);

[0021]FIG. 11 shows the algorithm of the preferred embodiment of the present invention (No. 10);

[0022]FIG. 12 shows the pseudo-code of a routine according to the preferred embodiment of the present invention (No. 1);

[0023]FIG. 13 shows the pseudo-code of a routine according to the preferred embodiment of the present invention (No. 2);

[0024]FIG. 14 shows the pseudo-code of a routine according to the preferred embodiment of the present invention (No. 3);

[0025]FIG. 15 shows the pseudo-code of a routine according to the preferred embodiment of the present invention (No. 4);

[0026]FIG. 16 shows the pseudo-code of a routine according to the preferred embodiment of the present invention (No. 5);

[0027]FIG. 17 shows the pseudo-code of a routine according to the preferred embodiment of the present invention (No. 6); and

[0028]FIG. 18 shows the pseudo-code of a routine according to the preferred embodiment of the present invention (No. 7).

DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0029] In the preferred embodiment of the present invention, a blocked algorithm is adopted to solve the tri-diagonalization of the eigenvalue problem. The algorithm for calculating a divided block is recursively applied and the calculation density in the update is improved. Consecutive accesses to a matrix vector product can also be made possible utilizing symmetry in order to prevent a plurality of discontinuous pages of memory from being accessed. If data are read across a plurality of pages of cache memory, sometimes the data cannot be read at one time and the cache memory must be accessed twice. In this case, the performance of the computer degrades. Therefore, data is prevented from spanning a plurality of pages of cache memory.

[0030] When applying Householder conversion to the eigenvector of a tri-diagonalized matrix and calculating the eigenvector of the original matrix, calculation density is improved by bundling every 80 iterations of the Householder conversion and calculating three matrix elements.

[0031] In the preferred embodiment of the present invention, conventional methods are used to calculate an eigenvalue based on a tri-diagonalized matrix and to calculate the eigenvector of the tri-diagonalized matrix.

[0032]FIG. 1 shows the hardware configuration of a shared-memory type scalar parallel computer assumed in the preferred embodiment of the present invention.

[0033] Each of processors 10-1 through 10-n has primary cache memory, and this primary cache memory is sometimes built into each processor. Each of the processors 10-1 through 10-n is also provided with each of secondary cache memories 13-1 through 13-n, and each of the secondary cache memories 13-1 through 13-n is connected to an interconnection network 12. The interconnection network 12 is also provided with memory modules 11-1 through 11-n, which are shared memories. Each of the processors 10-1 through 10-n reads necessary data from one of the memory modules, stores the data in one of the secondary cache memories 13-1 through 13-n or one of the primary cache memories through the interconnection network 12, and performs calculation.

[0034] In this case, the speed of reading data from one of the memory module 11-1 through 11-n into one of the secondary cache memories 13-1 through 13-n or one of the primary cache memories and the speed of writing calculated data into one of the memory modules 11-1 through 11-n from one of the primary cache memories is very low compared with the calculation speed of each of the processors 10-1 through 10-n. Therefore, the frequent occurrence of such reading or writing degrades the performance of the entire computer.

[0035] Therefore, in order to keep the performance of the entire computer high, an algorithm that reducses the number of accesses to each of the memory modules 11-1 through 11-n as much as possible and performs as much calculation as possible in a local system comprised of the secondary cache memories 13-1 through 13-n, primary cache memories and processors 10-1 through 10-n is needed.

[0036] <Method for Calculating an Eigenvalue and an Eigenvector>

[0037] 1. Tri-Diagonalization Part

[0038] 1) Tri-Diagonalization

[0039] a) Mathematical Algorithm for Divided Tri-Diagonalization

[0040] A matrix is tri-diagonalized for each block width. Specifically, a matrix is divided into blocks and each divided block is tri-diagonalized using the following algorithm.

[0041]FIGS. 2 through 11 show the algorithm of the preferred embodiment of the present invention.

[0042]FIG. 2 shows the process of the m-th divided block. In this case, a block is the rectangle with a column and a row, which are indicated by dotted lines, as each side shown in FIG. 2.

[0043] For the process for a last block, the algorithm is applied to 2×2 matrix with block width 2 located in the left hand corner and then the entire process terminates.

[0044] do i=1,blks

[0045] step1: Create a Householder vector u based on the (n+1)th row vector of A_(n).

[0046] step2: Calculate v_(i)=A_(n+i)u and w_(i)=v_(i)−u (u^(t)v)/2.

[0047] step3: Update as U_(i)=(U_(i−1)u_(i)) and W_(i)=(W_(i−1),wi) (In this case, (U_(i−1),u_(i)) expands the matrix by one column by creating matrix U_(i) based on matrix U_(i−1) by adding one column)

[0048] step4: if(i<blks) then

[0049] Update the (n+i+1)th column of A_(n).

A _(n)(*,n+i+1)=A _(n)(*,n+i+1)−U _(i) W _(i)(n+i+1)^(t) −W _(i) U _(i)(n+i+1,*)^(t)

[0050] endif

[0051] enddo

[0052] step5: A_(n+blks)=A_(n)−U_(blks)W_(blkS) ^(t)−W_(blks)U_(blks) ^(t)

[0053] Tri-diagonalization by divided Householder conversion

[0054] Explanation of Householder conversion

[0055] v=(v₁, v₂, . . . , v_(n))

[0056] |v|²=v*v=h²

[0057] If U_(v)=(h, 0, . . . , 0)^(t), there is the relationship of U_(v)=v−(v₁−h, v₂, . . . , v_(n)).

[0058] U=(1−uu^(t)/|uβ²)=(1−αuu^(t)), where u=(v₁−h, v₂, . . . , v_(n)).

[0059] In the calculate below, α is neglected.

A _(n+1) =U ^(t) A _(n) U=(1−uu ^(t))A(1−uu ^(t))=A _(n) −uu ^(t) A _(n) −A _(n) uu ^(t) +uu ^(t) A _(n) uu ^(t) =A _(n) −uw ^(t) −uu ^(t) u ^(t) v/2−wu ^(t) u ^(t) v/2+uu ^(t) u ^(t) v=A _(n) −uw ^(t) −wu ^(t)  (*)

[0060] where w=v−u(u^(t)v)/2 and v=A_(n)u

[0061] This is repeated,

A _(n+k) =A _(n) −U _(k) W _(k) ^(t) −W _(k) U _(k) ^(t)  (**)

[0062] As the calculation in the k-th step, V_(n) can be calculated according to equations (*) and (**) as follows.

v _(k) =A _(n) u _(k) −U _(k−1) W _(k−1) ^(t) u _(k) −W _(k−1) U _(k−1) ^(t) u _(k)  (***)

w _(k) =v _(k) −u _(k) u _(k) ^(t) v _(k)/2

U _(k)=(U _(k−1) , u _(k)), W _(k)=(W _(k−1) , w _(k))

A _(n+k) =A _(n) −U _(k) W _(k) ^(t) −W _(k) U _(k) ^(t)

[0063] b) Storage of Information Constituting Householder Conversion

[0064] The calculation of an eigenvector requires the Householder conversion, which has been used in the tri-diagonalization. For this reason, U_(n) and α are stored in the position of a vector constituting the Householder conversion. α is stored in the position of a corresponding diagonal element.

[0065] c) Method for Efficiently Calculating U_(i)

[0066] In order to tri-diagonalize each block, the following vectors used for Householder conversion must be updated. In order to localize these calculations as much as possible, a submatrix of the given block width must be copied into a work area, is tri-diagonalized and is stored in the original area. Instead of updating a subsequent column vector for each calculation, calculation is performed in the form of a matrix product with improved calculation density. Therefore, the tri-diagonalization of each block is performed by a recursive program.

[0067] recursive subroutine trid (width, block area pointer)

[0068] if(width<10) then

[0069] c Tri-diagonalize the block with the width.

[0070] Create v_(i) and w_(i) based on vector u needed for Householder conversion and a matrix vector product.

[0071] Combine u_(i) and w_(i) with U and W, respectively.

[0072] else

[0073] c Divide a block width into halves.

[0074] C Tri-diagonalize the former half block.

[0075] call trid (width of the former half, area of the former half)

[0076] c Divide a block and update the latter half divided by a division line.

[0077] Update B=B−UW^(t)−WU^(t).

[0078] c Then, tri-diagonalize the latter half.

[0079] call trid (width of the latter half, area of the latter half)

[0080] return

[0081] end

[0082] As shown in FIG. 3, a block is copied into a work area U and the block is tri-diagonalized by a recursive program. Since the program is recursive, the former half shown in FIG. 3 is tri-diagonalized when the recursive program is called for the update process of the former half. The latter half is updated by the former half and then is tri-diagonalized.

[0083] As shown in FIGS. 4A through 4F, when the recursive program is called to a depth of 2, the shaded portion shown in Fig. A is updated to B in the first former half process and then the shaded portion shown in FIG. 4C is updated and lastly the shaded portion shown in FIG. 4F is updated. In parallel calculation at the time of update, the block matrix of the updated portion is evenly divided vertically into columns (divided in a row vector direction), and the update of each portion is performed in parallel by a plurality of processors.

[0084] The calculation of FIG. 4B is performed after the calculation of FIG. 4A, the calculation of FIG. 4D is performed after the calculation of Fig. C and the calculation of FIG. 4F is performed after the calculation of FIG. 4E.

[0085] As shown in FIG. 5, when the shaded portion of U is updated, the horizontal line portion of u and the vertical line portion of W are referenced. In this way, calculation density can be improved. Specifically, V_(n) can be calculated according to the following equation (**).

A _(n+k) =A _(n) −U _(k) W _(k) −W _(k) U _(k) ^(t)  (**)

[0086] In this case, the reference pattern of U and W is determined according to the following equation (***).

v _(k) =A _(n) u _(k) −U _(k−1) W _(k−1) ^(t) u _(k) −W _(k−1) U _(k−1) ^(t) u _(k)  (***)

[0087] v_(k) is calculated for the tri-diagonalization of the updated portion after the update of U shown in FIGS. 4A and 4B, 4C and 4D, and 4E and 4F, U and W are referenced and v_(k) is calculated using a matrix vector product. Since this is just a reference, and the update and reference of U have a common part, U and W can be efficiently referenced. Instead of updating A_(n) each time, only a necessary portion is updated using U and W. Using equation (**), the calculation speed of the entire update is improved, and performance is improved accordingly. Although equation (***) is extra calculation, it does not effect the performance of the entire calculation as long as the block width is kept narrow.

[0088] For example, if four computers perform the parallel process, in the calculation of W_(k−1) ^(t)u_(k) and U_(k−1) ^(t)u_(k) of equation (***), the shaded portion is divided in the direction of a vertical line(divided by horizontal lines), and parallel calculation is performed. As for the product of the results, the shaded portion is divided in the direction of a broken line, and parallel calculation is performed.

[0089] Parallel Calculation of v_(i)=A_(n)u_(i)

[0090] As shown in FIG. 6, each processor divides the shaded portion in the second dimensional direction utilizing the symmetry of A_(n), that is, A_(n)=A_(n) ^(t) and each processor calculates v_(i) by A_(n)(*, ns:ne)^(t)u_(i).

[0091] 2)Parallel Calculation in Shared-Memory Type Scalar Parallel Computer

[0092] a) A Storage Area for U and W is Allocated in Shared Memory.

[0093] A block area to be tri-diagonalized is copied into a work area allocated separately and tri-diagonalization is applied to the area.

[0094] The parallel calculation of the recursive program described above is as follows.

[0095] (1) Necessary vectors are calculated according to the following equation of step 4 in order to calculate u_(i) needed to perform Householder conversion

A _(n)(*,n+i+1)=A _(n)(*,n+i+1)−U _(i) W _(i)(n+i+1)^(t) −W _(i) U _(i)(n+i+1,*)^(t)

[0096] (2) v_(i) is calculated in step 2

[0097] This is calculated by making u_(i) act on the following equation (**).

A _(n+k) =A _(n) −U _(k) W _(k) ^(t) −W _(k) U _(k) ^(t)

[0098] In this calculation, the product of A_(n) and u_(i), and the product of U_(k)W_(k) ^(t)−W_(k)U_(k) ^(t) and u_(i) are processed in parallel.

[0099] The block is copied in a work area and care must be paid so as not to update the necessary portion of A_(n). The block is divided into matrices extended in a column vector direction(divided into columns) utilizing the symmetry of A_(n), and parallel calculation is performed.

[0100] (3) In the recursive program, a block area is updated utilizing the following equation.

A _(n+k) =A _(n) −U _(k) W _(k) ^(t) −W _(k) U _(k) ^(t)

[0101] In this way, the amount of calculation of (1) is reduced.

[0102] 3)Update in Step 5

[0103] Utilizing symmetry during update, only the lower half of a diagonal element is calculated. In parallel calculation, if the number of CPUs is #CPU, in order to balance load, a sub-array, in which a partial matrix to be updated is stored, is evenly divided into 2×#CPU in the second dimensional direction and the CPUs are numbered from 1 to 2×#CPU. The i-th processor of each of 1 through #CPU updates in parallel the i-th and (2×#CPU+1−i)th divided sub-arrays.

[0104] Then, calculated result is copied into the upper half. Similarly, this is also divided and the load is balanced. In this case, portions other than the diagonal block are divided into fairly small blocks so that data are not read across a plurality of pages of cache memory and are copied. The lower triangular matrix is updated by A_(n+k)=A_(n)−U_(k)W_(k) ^(t)−W_(k)U_(k) ^(t). In this case, the lower triangular matrix is divided into #CPU×2 of column blocks, two outermost blocks, one at each end are sequentially paired. Each CPU updates such a pair. FIG. 7 shows a case where four CPUs are provided.

[0105] After the lower triangular part is updated, the same pairs consisting of blocks 1 through 8 are transposed into an upper triangle portion and are copied into u1 through u8.

[0106] In this case, the block is divided into small internal square blocks and is transposed using the cache. Then, the blocks are processed in parallel as during an update.

[0107] Explanation on the Improvement of the Performance by Transposition in the Cache

[0108] As shown in FIG. 8, square blocks are transposed and converted in ascending order of block numbers. The lower triangle of square area 1 is copied into the continuous area of memory, is transposed into rows by accessing in the direction of row and stored in the upper triangle of square area 1. Each square in the first column, namely squares 2 through 8, is copied and transposed into the corresponding square in the first row.

[0109] 2. Calculation of Eigenvectors

[0110] a) Basic Algorithm

[0111] Vector u_(n) is stored, then (1−2*uu^(t)/(u^(t)u)) is created and (1−2*uu^(t)/(u^(t)u)) is multiplied by the vector.

[0112] If tri-diagonalization is performed, the original eigenvalue problem can be transformed as follows.

[0113] Q_(n−2) . . . Q₂Q₁AQ₁ ^(t)Q₂ ^(t) . . . Q_(n−2) ^(t)Q_(n−2) . . . Q₂Q₁x=λQ_(n−2) . . . Q₂Q₁x

[0114] Conversion is performed by calculating x=Q₁ ^(t)Q₂ ^(t) . . . Q_(n−3) ^(t)Q_(n−2) ^(t)y based on the eigenvector y calculated by solving the tri-diagonalized eigenvalue problem.

[0115] b) Block Algorithm of the Preferred Embodiment of the Present Invention and Parallel Conversion Calculation of Eigenvectors

[0116] When calculating many or all eigenvectors, the eigenvectors of tri-diagonal matrix are evenly assigned to each CPU, and each CPU performs the conversion described above in parallel. In this case, approximately 80 conversion matrices are collectively converted.

[0117] Each conversion matrix Q_(i) ^(t) can be expressed as 1+α_(i)u_(i)u_(i) ^(t). The product of these matrices can be expressed as follows. $1 + {\sum\limits_{i = n}^{n + k - 1}{u_{i}\left( {\sum\limits_{j = 1}^{n + k - 1}{b_{ij}u_{j}^{t}}} \right)}}$

[0118] where

[0119] b_(i,j): The collection of scalar coefficients other than u_(i)u_(j) at the leftmost and rightmost ends

[0120] b_(i,j) becomes an upper triangular matrix. Each conversion matrix Q_(i) ^(t) can be transformed into 1+UBU^(t). Using this transformation, calculation density can be improved, and calculation speed can be improved accordingly. FIG. 9 shows a typical matrix B.

[0121] Although the method described above has three steps, matrices to be processed become are U and B according to such memory access. Since B can be made fairly small, high efficiency can be obtained. After the (m−1)th b_(i,j) is calculated, all b_(i,j) are multiplied by (1+α_(m)U_(m)U_(m) ^(t)), and the following expression can be obtained. $1 + {\sum\limits_{i}{u_{i}\left( {\sum\limits_{j}{b_{ij}u_{j}^{t}}} \right)}} + {\alpha_{m}U_{m}U_{m}^{t}} + {U_{m}{\sum\limits_{i}{\alpha_{m}U_{m}^{t}{U_{i}\left( {\sum\limits_{j}{b_{ij}u_{j}^{t}}} \right)}}}}$

[0122] If i and j are swapped in the sum of the last term, the expression can be modified as follows. U_(m)(∑(∑α_(m)u_(m)^(t)u_(i)b_(ij))u_(j)^(t))

[0123] The item located in the innermost parenthesis can be regarded as b_(m,j) (j=m+1, . . . , n+k). In this case, b_(m,m) is α_(m).

[0124] A square work array W2 is prepared, and first, α₁U_(i)U_(j) ^(t) is stored in the upper triangle of w2(i,j). α_(I) is stored in the diagonal element.

[0125] The method described above can be calculated by sequentially adding one row on the top of each of the matrices upwards beginning with the 2×2 upper triangular matrix in the lower right corner.

[0126] If each of the elements is calculated beginning with the rightmost row element, calculation can be performed in the same area since B is an upper triangular matrix and the updated portion is not referenced. In this way, a coefficient matrix located in the middle of three matrix products can be calculated using only very small areas.

[0127]FIG. 10 shows a typical method for calculating the eigenvalue described above.

[0128] Block width is assumed to be nbs.

[0129] First, inner product α_(j)u_(i)·u_(j) is calculated and is stored in the upper half of B.

[0130] α_(i) is stored in the diagonal element.

[0131] Then, calculation is performed as follows.

[0132] do i1=nbs−2,1,−1

[0133] do i2=nbs, i1+1,−1

[0134] sum=w2(i1,i2)

[0135] do i3=i2−1,i1+1,−1

[0136] sum=sum+w2(i1,i3)*w2(i3,i2)

[0137] enddo

[0138] w2(i1,i2)=sum

[0139] enddo

[0140] enddo

[0141] do i2=nbs,1,−1

[0142] do i1=i2−1,1,−1

[0143] w2(i1,i2)=w2(i1,i2)*w2(i2,i2)

[0144] enddo

[0145] enddo

[0146]FIG. 11 shows a typical process of converting the eigenvector calculated above into the eigenvector of the original matrix.

[0147] The eigenvector is converted by a Householder vector stored in array A. The converted vector is divided into blocks. The shaded portion shown in FIG. 11 is multiplied by the shaded portion of EV, and the result is stored in W. W2 is also created based on block matrix A. W2 and W are multiplied. Then, the block portion of A is multiplied by the product of W2 and W. Then, the shaded portion of EV is updated using the product of the block portion of A and the product of W2 and W.

[0148] 3.Eigenvalue/Eigenvector of Hermitian Matrix

[0149] An algorithm for calculating the eigenvalue/eigenvector of a Hermitian matrix replaces the transposition in the tri-diagonalization of a real symmetric matrix with transposition plus complex conjugation (t→H). A Householder vector is created by changing the magnitude of the vector in order to convert the vector into the scalar multiple of the original element.

[0150] The calculated tri-diagonal matrix is a Hermitian matrix, and this matrix is scaled by a diagonal matrix with the absolute value of 1.

[0151] A diagonal matrix is created as follows.

[0152] d_(i)=1.0, d_(i+1)=h_(i+1)/|h_(i+1)|*d_(i)

[0153]FIGS. 12 through 18 show the respective pseudo-code of routines according to the preferred embodiment of the present invention.

[0154]FIG. 12 shows a subroutine for tri-diagonalizing a real symmetric matrix.

[0155] Array a is stored in the lower triangle of a real symmetric matrix. The tri-diagonal matrix and sub-diagonal portion are stored in daig and sdiag, respectively. Information needed for conversion is stored in the lower triangle of a as output.

[0156] U stores blocks to be tri-diagonalized. V is an area for storing W.

[0157] nb is the number of blocks, and nbase indicates the start position of a block.

[0158] After subroutine “copy” is executed, a block to be tri-diagonalized in u(nbase+1:n,1:iblk), routine blktrid is called and LU analysis is performed. Then, the processed u(nbase+1:n,1:iblk) is written back into the original matrix a. In subsequent processes, the last remaining block is tri-diagonalized using subroutine blktrid.

[0159]FIG. 13 shows the pseudo-code of a tri-diagonalization subroutine.

[0160] This subroutine is a routine for tri-diagonalizing block matrices and is recursively called. nbase is an offset indicating the position of a block. istart is the intra-block offset of a reduced sub-block to be recursively used, and indicates the position of the target sub-block. It is set to “1” when called for the first time. nwidth represents the size of a sub-block.

[0161] If nwidth is less than 10, subroutine btunit is called. Otherwise, istart is stored in istart2, a half of nwidth is stored in nwidth2. The sub-block is tri-diagonalized by subroutine blktrid, and then Barrier synchronization is applied.

[0162] Furthermore, the sum of istart and nwidth/2 is stored in istart3, and nwidth-nwidth/2 is stored in nwidth 3. Then, a value is set in is2, is3, ie2 and ie3, is and ie, each of which indicates the start or end position of a block, and len and iptr are also set. Then, after calculation is performed according to the expression shown in FIG. 13, the result is stored in u(is:ie,is3:ie3), and Barrier synchronization is applied. Then, tri-diagonalization subroutine blktrid is called and the sub-block is processed. Then, the subroutine process terminates.

[0163]FIG. 14 shows the pseudo-code of the internal routine of a tri-diagonalization subroutine.

[0164] In the internal tri-diagonalization subroutine btunit, after necessary information is stored, block start iptr2, width len, start position “is” and end position ie are determined, and Barrier synchronization is applied. Then, u(is:ie,i)t*u(is:ie,i) is stored in tmp, and Barrier synchronization is applied. Then, each value is calculated and is stored in a respective corresponding array. In this routine, sum and sqrt mean to sum and to calculate a square root. Lastly, Barrier synchronization is applied.

[0165] Then, v(is:ie,i) is calculated, and Barrier synchronization is applied. Then, lens2, isx, iex, u and v are updated, and Barrier synchronization is applied. Furthermore, v(is:ie,i) is updated, and Barrier synchronization is applied. Furthermore, v(is:ie,i)^(t)*u(is:ie,i) is calculated, tmp is stored and Barrier synchronization is applied.

[0166] Then, a value is set in beta, and Barrier synchronization is applied. Then, v is updated by calculation using beta, and Barrier synchronization is applied.

[0167] Then, if i<iblk and ptr2<n−2, u(is:ie,i+1) is updated. Otherwise, u(1:ie,i;1:i+2) is updated using another expression and the process terminates. After the execution of this subroutine, the allocated threads are released.

[0168]FIG. 15 shows the respective pseudo-code of a routine for updating the lower half of a matrix based on u and v, a routine for updating a diagonal matrix portion and a copy routine.

[0169] In this code, nbase and nwidth are an offset indicating the position of a block and block width, respectively.

[0170] In this subroutine update, after arrays a, u and v are allocated, Barrier synchronization is applied. Then, after blk, nbase2, len, is1, ie1, nbase3, isr and ier are set, each of a(ie1:n,is1:ie1) and a(ier+1:n,isr:ier) is updated. Then, a subroutine trupdate is called twice, Barrier synchronization is applied and the process is restored to the original routine.

[0171] In subroutine copy, len, is1, len1, nbase, isr and lenr are set, bandcp is executed twice and the process is restored to the original routine.

[0172]FIG. 16 shows the pseudo-code of a routine copying an updated lower triangle in an upper triangle.

[0173] In subroutine bandcp, nb, w, nn and loopx are set. Then, in a loop do, TRL(a(is2:is2+nnx−1,is2:is2+nnx)) and TRL(w(1:nnx,1:nnx))^(t) are stored in TRL(w(1:nnx,1:nnx)) and TRU(a(is2:is2+nnx−1,is:is+nnx)), respectively. In this case, TRL and TRU represent a lower triangle and an upper triangle, respectively.

[0174] Then, w(1:nnx,1:nnx) and a(is2:is2+nnx, is3:is3+nnx−1) are updated. Then, w(1:ny,1:nx) and a(is2:is2+nnx,is3:n) are updated.

[0175] Then, after the do loop has finished, the process is restored to the original routine.

[0176]FIG. 17 shows the pseudo-code of a routine for converting the eigenvector of a tri-diagonal matrix into the eigenvector of the original matrix.

[0177] In this case, the eigenvector of a tri-diagonal matrix is stored in ev(1:n,1:nev). a is the output of tri-diagonalization and stores information needed for conversion in a lower diagonal portion.

[0178] Subroutine convev takes array arguments a and ev.

[0179] Subroutine convev creates threads and performs a parallel process.

[0180] Barrier synchronization is applied and len, is, ie and nevthrd are set. Then, routine convevthrd is called, and Barrier synchronized is applied after restoration and the process terminates.

[0181]FIG. 18 shows the pseudo-code of a routine for converting eigenvectors.

[0182] In subroutine convevthrd, block width is stored in blk, and a, ev, w and w2 are taken as arrays.

[0183] First, if width is less than 0, the original routine is restored without performing any process. In this case, numb1k and nfbs are set, and a value stored in a diagonal element at the time of tri-diagonalization with a code the reverse of the above (−a(i,i))is input in alpha. ev(i+1:n,1:iwidth)^(t)*a(i+1:n,i) is input in x(1:iwidth), and ev is updated using ev(i+1:n,1:iwidth)^(t)*a(i+1:n,i), alpha and a. Furthermore, in a subsequent do sentence, is and ie are set, a(is+1:n,is:ie)^(t)*ev(is+1:n,1:iwidth) is replaced with a(is+1:n,is:ie)^(t)*ev(is+1:n,1:iwidth) and w(1:blk,1:iwidth) is updated by TRL(a(ie+1:is, is:ie))^(t)*ev(ie+1:is,1:iwidth). In this case, TRL is a lower triangular matrix.

[0184] The diagonal element vector of a(is:ie,is:ie) is stored in the diagonal element vector DIAG(w2) of w2.

[0185] In a subsequent do sentence, w2(i1,i2) is updated by w2(i1,i2)*(a(is+12:n,is+i2−1)^(t)*a(is+i2:n,is;i1−1)). Furthermore, in a subsequent do sentence, w2(i1,i2) is updated by w2(i1,i2)+w2(i1,i1+1:i2−1)*w2(i1+1:i2−1,i2).

[0186] Furthermore, in a subsequent do sentence, w2(i1,i2) is updated by w2(i1,i2)*w2(i2,i2). Then, w(1:blk,1:iwidth), ev(is+n:n,1:iwidth) and ev(ie+1:is,1:iwidth) are updated and the process is restored to the original routine.

[0187] According to the present invention, a high-performance and scalable eigenvalue/eigenvector parallel calculation method can be provided using a shared-memory type scalar parallel computer.

[0188] According to the preferred embodiment of the present invention, in particular, the speed of eigenvector conversion calculation can be improved to be about ten times as fast as the conventional method. The eigenvalue/eigenvector of a real symmetric matrix calculated using these algorithms can also be calculated using Sturm's method and an inverse repetition method. The speed of calculation using seven CPUs is 6.7 times faster than the function of the numeric value calculation library of SUN called SUN performance library. The speed of the method of the present invention is also 2.3 times faster than a method for calculating the eigenvalue/eigenvector of a tri-diagonal matrix by a “divide & conquer” method, of another routine from SUN (in this case, it is inferior in function: eigenvalue/eigenvector cannot be selectively calculated).

[0189] The eigenvalue/eigenvector of a Hermitian matrix obtained using these algorithms can also be calculated using Sturm's method and an inverse repetition method. The speed of the method of the present invention using seven CPUs is 4.8 times faster than the function of the numeric value calculation library of SUN called the SUN performance library. The speed of the method of the present invention is also 3.8 times faster than a method for calculating the eigenvalue/eigenvector of a tri-diagonal matrix by a “divide & conquer” method, of another routine of SUN (in this case, it is inferior in function: eigenvalue cannot be selectively calculated).

[0190] For basic algorithms of matrix computations, see the following textbook:

[0191] G. H. Golub and C. F. Van Loan, “Matrix Computatrions” the third edition, The Johns Hopkins University Press (1996).

[0192] For the parallel calculation of tri-diagonalization, see the following reference:

[0193] J. Choi, J. J. Dongarra and D. W. Walker, “The Design of a Parallel Dense Linear Algebra Software Library: Reduction to Hessenberg, Traditional, and Bi-diagonal Form”, Engineering Physics and Mathematics Division, Mathematical Sciences Section, prepared by the Oak Ridge National Laboratory managed by Martin Marietta Energy System, Inc., for the U.S. Department of Energy under Contract No. DE-AC05-840R21400, ORNL/TM-12472.

[0194] In this way, a high-performance and scalable eigenvalue/eigenvector calculation method can be realized. 

What is claimed is:
 1. A program enabling a shared-memory type scalar parallel computer to realize a parallel processing method of an eigenvalue problem for a shared-memory type scalar parallel computer, comprising: dividing a real symmetric matrix or a Hermitian matrix to be processed into blocks, copying each divided block into a work area of a memory and tri-diagonalizing the blocks using products between the blocks; calculating an eigenvalue and an eigenvector based on the tri-diagonalized matrix; and converting the eigenvector calculated based on the tri-diagonalized matrix by Householder conversion in order to transform the calculation into parallel calculation of matrices with a prescribed block width and calculating an eigenvector of an original matrix.
 2. The program according to claim 1, wherein in said tri-diagonalization step, each divided block is updated by a recursive program.
 3. The program according to claim 1, wherein in said tri-diagonalization step, each divided block is further divided into smaller blocks so that data may not be read across a plurality of pages of a cache memory and each processor can calculate such divided blocks in parallel.
 4. The program according to claim 1, wherein in said original matrix eigenvector step, a matrix, to which Householder conversion is applied, can be created by each processor simultaneously creating an upper triangular matrix, which is a small co-efficient matrix that can be processed by each processor.
 5. The program according to claim 1, wherein in said original matrix eigenvector calculation step, the said eigenvector of the original matrix can be calculated by evenly dividing the second dimensional direction of a stored bi-dimensional array in accordance with the number of processors and assigning each divided area to a processor.
 6. A parallel processing method of an eigenvalue problem for a shared-memory type scalar parallel computer, comprising: dividing a real symmetric matrix or a Hermitian matrix to be calculated into blocks, copying each divided block into a work area of memory and tri-diagonalizing the blocks using products between the blocks; calculating an eigenvalue and an eigenvector based on the tri-diagonalized matrix; and converting the eigenvector calculated based on the tri-diagonalized matrix by Householder conversion in order to transform the calculation into parallel calculation of matrices with a prescribed block width and calculating an eigenvector of an original matrix.
 7. The parallel processing method according to claim 6, wherein in said tri-diagonalization step, each divided block is updated by a recursive program.
 8. The parallel processing method according to claim 6, wherein in said tri-diagonalization step, each divided block is further divided into smaller blocks so that data may not be read across a plurality of pages of a cache memory and each processor can process such divided blocks in parallel.
 9. The parallel processing method according to claim 6, wherein in said original matrix eigenvector step, a matrix, to which Householder conversion is applied, can be created by each processor simultaneously creating an upper triangular matrix, which is a small co-efficient matrix that can be processed by each processor.
 10. The parallel processing method according to claim 6, wherein in said original matrix eigenvector calculation step, the said eigenvector of the original matrix can be calculated by evenly dividing the second dimensional direction of a stored bi-dimensional array in accordance with the number of processors and assigning each divided area to a processor. 